const { pool, router, resJson } = require('../connect')
const userSQL = require('../db/userSQL')
const multiparty = require('multiparty')
var fs = require('fs');
var path = require('path');
const { format } = require('path');
/**
 * 用户登录功能
 */
router.get('/login', (req, res) => {
  let user = {
    username: req.query.name,
    password: req.query.password
  }
  let _res = res;
  // 判断参数是否为空
  if (!user.username) {
    return resJson(_res, {
      code: -1,
      msg: '用户名不能为空'
    })
  }
  if (!user.password) {
    return resJson(_res, {
      code: -1,
      msg: '密码不能为空'
    })
  }
  let _data;
  // 从连接池获取连接
  pool.getConnection((err, conn) => {
    conn.query(userSQL.queryByNamePassword, [user.username, user.password], (e, result) => {
      if (e) _data = {
        code: -1,
        msg: e
      }
      console.log(result)
      //通过用户名和密码索引查询数据，有数据说明用户存在且密码正确，只能返回登录成功，否则返回用户名不存在或登录密码错误
      if (result && result.length) {
        _data = {
          msg: '登录成功',
          data:{
            url:result[0].url
          }
        }
      } else {
        _data = {
          code: -1,
          msg: '用户名不存在或登录密码错误'
        }
      }
      resJson(_res, _data)
    })
    pool.releaseConnection(conn) // 释放连接池，等待别的连接使用
  })
})

/**
 * 注册用户功能
 */

router.get('/register', (req, res) => {
  // 获取前台页面传过来的参数
  let user = {
    username: req.query.name,
    password: req.query.password
  }
  let _res = res;
  // 判断参数是否为空
  if (!user.username) {
    return resJson(_res, {
      code: -1,
      msg: '用户名不能为空'
    })
  }

  if (!user.password) {
    return resJson(_res, {
      code: -1,
      msg: '密码不能为空'
    })
  }
  let _data;
  // 整合参数
  // 从连接池获取连接
  pool.getConnection((err, conn) => {
    // 查询数据库该用户是否已存在
    conn.query(userSQL.queryByName, user.username, (e, r) => {
      if (e) _data = {
        code: -1,
        msg: e
      }
      if (r) {
        //判断用户列表是否为空
        if (r.length) {
          //如不为空，则说明存在此用户
          _data = {
            code: -1,
            msg: '用户已存在'
          }
        } else {
          //插入用户信息
          conn.query(userSQL.insert, user, (err, result) => {
            if (result) {
              _data = {
                msg: '注册成功'
              }
            } else {
              _data = {
                code: -1,
                msg: '注册失败'
              }
            }
          })
        }
      }
      setTimeout(() => {
        //把操作结果返回给前台页面
        resJson(_res, _data)
      }, 200);
    })
    pool.releaseConnection(conn) // 释放连接池，等待别的连接使用
  })
})
/**
 * 修改密码
 */
router.get('/updatePassword', (req, res) => {
  let user = {
    username: req.query.name,
    oldPassword: req.query.oldPassword,
    newPassword: req.query.newPassword,
    againPassword: req.query.againPassword
  }
  let _res = res;
  // 判断参数是否为空
  if (!user.username) {
    return resJson(_res, {
      code: -1,
      msg: '用户名不能为空'
    })
  }
  if (!user.oldPassword) {
    return resJson(_res, {
      code: -1,
      msg: '旧密码不能为空'
    })
  }
  if (!user.newPassword) {
    return resJson(_res, {
      code: -1,
      msg: '新密码不能为空'
    })
  }
  if (!user.againPassword || user.againPassword !== user.newPassword) {
    return resJson(_res, {
      code: -1,
      msg: '请确认新密码或两次新密码不一致'
    })
  }
  // 整合参数
  // 从连接池获取连接
  pool.getConnection((err, conn) => {
    // 查询数据库该用户是否已存在
    conn.query(userSQL.queryByNamePassword, [user.username, user.oldPassword], (e, r) => {
      if (e) _data = {
        code: -1,
        msg: e
      }
      if (r) {
        //判断用户列表是否为空
        if (r.length) {
          //如不为空，则说明存在此用户且密码正确
          conn.query(userSQL.updateUser, [{
            password: user.newPassword
          }, user.username], (err, result) => {
            console.log(err)
            if (result) {
              _data = {
                msg: '密码修改成功'
              }
            } else {
              _data = {
                code: -1,
                msg: '密码修改失败'
              }
            }
          })

        } else {
          _data = {
            code: -1,
            msg: '用户不存在或旧密码输入错误'
          }
        }
      }
      setTimeout(() => {
        //把操作结果返回给前台页面
        resJson(_res, _data)
      }, 200);
    })
    pool.releaseConnection(conn) // 释放连接池，等待别的连接使用
  })
})
/**
 * 删除用户
 */
router.get('/deleteUser', (req, res) => {
  // 获取前台页面传过来的参数
  let user = {
    username: req.query.name
  }
  let _res = res;
  // 判断参数是否为空
  if (!user.username) {
    return resJson(_res, {
      code: -1,
      msg: '用户名不能为空'
    })
  }
  let _data;
  // 整合参数
  // 从连接池获取连接
  pool.getConnection((err, conn) => {
    // 查询数据库该用户是否已存在
    conn.query(userSQL.queryByName, user.username, (e, r) => {
      if (e) _data = {
        code: -1,
        msg: e
      }
      if (r) {
        //判断用户列表是否为空
        if (r.length) {
          //如不为空，则说明存在此用户
          conn.query(userSQL.deleteUser, user.username, (err, result) => {
            if (err) _data = {
              code: -1,
              msg: e
            }
            if (result) {
              _data = {
                msg: '删除用户操作成功'
              }
            }
          })
        } else {
          _data = {
            code: -1,
            msg: '用户不存在，操作失败'
          }
        }
      }
      setTimeout(() => {
        //把操作结果返回给前台页面
        resJson(_res, _data)
      }, 200);
    })
    pool.releaseConnection(conn) // 释放连接池，等待别的连接使用
  })
})

//上传头像接口
router.post('/file_upload', function (req, res) {
  var uploadedPath;
  var dstPath;
  var nameSQL;
  var realPath;
  var _res = res;
  var path;
  let _data;
  var form = new multiparty.Form();
  form.uploadDir = '../public/images';
  form.parse(req);
  form.on('field', (name, value) => { // 接收到数据参数时，触发field事件
    console.log(name, value)
    nameSQL = value;
  })
  form.on('file', (name, file, ...rest) => { // 接收到文件参数时，触发file事件
    realPath = file.path;
    /*
    fs.renameSync(file.path, nameSQL + "_head.jpg", function (err) {
      if (err) {
        console.log('rename error: ' + err);
      } else {
        console.log('rename ok');
      }
    });*///估计是无用，暂时不要重命名。冗余一下！
    pool.getConnection((err, conn) => {
      conn.query(userSQL.updateURL, [{
        url: realPath
      }, nameSQL], (err, result) => {
        if (err) {
          _data = {
            code: -1,
            msg: err
          }
        }
        if (result) {
          _data = {
            msg: realPath,
          }
        }
        //把操作结果返回给前台页面
        resJson(_res, _data)
      })
      pool.releaseConnection(conn)
    })
  })
  form.on('close', () => {  // 表单数据解析完成，触发close事件

  })

  //console.log(req.session.username)
  /*var des_file = path.join(__dirname, "../public/images/" + req.files[0].originalname);
  console.log("/images/" + req.files[0].originalname);
  fs.readFile(req.files[0].path, function (err, data) {
    fs.writeFile(des_file, data, function (err) {
      if (err) {
        console.log(err);
      } else {

        pool.getConnection((err, conn) => {
          var imgurl = "/images/ue/" + req.files[0].originalname;
          conn.query(userSQL.updateURL, imgurl, username, (err, result) => {
            if (err) _data = {
              code: -1,
              msg: e
            }
            if (result) {
              _data = {
                msg: '更新头像操作成功'
              }
            }
            setTimeout(() => {
              //把操作结果返回给前台页面
              resJson(_res, _data)
            }, 200);
          })
          pool.releaseConnection(conn)
        })
      }
    });
  });*/
})
module.exports = router;
